import sympy as sp

def chain_rule_demo_corrected():
    
    # 定义符号变量
    t = sp.Symbol('t')
    T_symbol = sp.Symbol('T')  # 中间变量符号
    
    # 示例1: 物体冷却过程 - 三层复合函数
    print("例1: 物体冷却速率分析")
    print("情景: 物体温度T随时间t变化: T = e^(-0.1t)")
    print("      测量设备读数R随温度T变化: R = ln(T+1)")
    print("问题: 求读数R随时间t的变化速率 dR/dt\n")
    
    # 正确的链式法则演示方法
    # 第一步：定义外函数 R = ln(T + 1)，其中T是符号变量
    R_external = sp.log(T_symbol + 1)
    dR_dT = sp.diff(R_external, T_symbol)  # dR/dT = 1/(T + 1)
    print(f"第一步（外函数求导）: dR/dT = {dR_dT}")
    
    # 第二步：定义内函数 T = e^(-0.1t)
    T_expression = sp.exp(-0.1 * t)
    dT_dt = sp.diff(T_expression, t)  # dT/dt = -0.1 * e^(-0.1t)
    print(f"第二步（内函数求导）: dT/dt = {dT_dt}")
    
    # 第三步：链式法则 dR/dt = dR/dT × dT/dt
    dR_dt_chain = dR_dT * dT_dt
    # 将中间变量T替换回实际表达式
    dR_dt_chain = dR_dt_chain.subs(T_symbol, T_expression)
    print(f"链式法则结果: dR/dt = {dR_dT} × {dT_dt}")
    print(f"              = {dR_dt_chain}")
    
    # 直接验证：构造复合函数后直接求导
    R_composite = sp.log(T_expression + 1)
    dR_dt_direct = sp.diff(R_composite, t)
    print(f"直接求导验证: dR/dt = {dR_dt_direct}")
    
    # 验证结果一致性（需要化简后比较）
    are_equal = sp.simplify(dR_dt_chain - dR_dt_direct) == 0
    print(f"结果一致: {are_equal}\n")
    
    # 示例2: 人口增长模型 - 两层复合函数
    print("例2: 人口增长分析")
    print("情景: 城市人口P随时间t增长: P = 1000 × t²")
    print("      城市面积A随人口P变化: A = sqrt(P)")
    print("问题: 求面积A随时间t的变化速率 dA/dt\n")
    
    # 使用中间符号变量方法
    P_symbol = sp.Symbol('P')  # 中间变量符号
    
    # 第一步：定义外函数 A = sqrt(P)
    A_external = sp.sqrt(P_symbol)
    dA_dP = sp.diff(A_external, P_symbol)  # dA/dP = 1/(2√P)
    print(f"第一步（外函数求导）: dA/dP = {dA_dP}")
    
    # 第二步：定义内函数 P = 1000 × t²
    P_expression = 1000 * t**2
    dP_dt = sp.diff(P_expression, t)  # dP/dt = 2000t
    print(f"第二步（内函数求导）: dP/dt = {dP_dt}")
    
    # 第三步：链式法则 dA/dt = dA/dP × dP/dt
    dA_dt_chain = dA_dP * dP_dt
    dA_dt_chain = dA_dt_chain.subs(P_symbol, P_expression)
    print(f"链式法则结果: dA/dt = {dA_dP} × {dP_dt}")
    print(f"              = {dA_dt_chain}")
    
    # 直接验证
    A_composite = sp.sqrt(P_expression)
    dA_dt_direct = sp.diff(A_composite, t)
    print(f"直接求导验证: dA/dt = {dA_dt_direct}")
    
    are_equal2 = sp.simplify(dA_dt_chain - dA_dt_direct) == 0
    print(f"结果一致: {are_equal2}")

# 运行修正后的函数
chain_rule_demo_corrected()